home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / screen-resolution-extra / screenresolution-mechanism.py < prev    next >
Text File  |  2009-10-08  |  11KB  |  290 lines
  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3. #
  4. # Copyright (C) 2008 Fluendo Embedded S.L. (www.fluendo.com)
  5. #
  6. # This program is free software; you can redistribute it and/or modify it under
  7. # the terms of the GNU General Public License as published by the Free Software
  8. # Foundation; either version 2 of the License, or (at your option) any later
  9. # version.
  10. #
  11. # This program is distributed in the hope that it will be useful, but WITHOUT
  12. # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13. # FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14. # details.
  15. #
  16. # You should have received a copy of the GNU General Public License along with
  17. # this program; if not, write to the Free Software Foundation, Inc.,
  18. # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19. #
  20. # taken from:
  21. # https://code.fluendo.com/remotecontrol/trac/browser/trunk/
  22. #         gnome_lirc_properties/backend.py?rev=217
  23. # 
  24. # modified by Harald Hoyer <harald@redhat.com>
  25. #
  26. # modified by Alberto Milone (tseliot) <albertomilone@alice.it>
  27.  
  28. import dbus, dbus.service, gobject, logging
  29. import os, os.path
  30. import sys
  31. from XKit import xutils, xorgparser
  32. import time
  33. import shutil
  34. import subprocess
  35.  
  36. # Modern flavors of dbus bindings have that symbol in dbus.lowlevel,
  37. # for old flavours the internal _dbus_bindings module must be used.
  38.  
  39. try:
  40.     # pylint: disable-msg=E0611
  41.     from dbus.lowlevel import HANDLER_RESULT_NOT_YET_HANDLED
  42.  
  43. except ImportError:
  44.     from _dbus_bindings import HANDLER_RESULT_NOT_YET_HANDLED
  45.  
  46. class AccessDeniedException(dbus.DBusException):
  47.     '''This exception is raised when some operation is not permitted.'''
  48.  
  49.     _dbus_error_name = 'com.ubuntu.screenresolution.Mechanism.AccessDeniedException'
  50.  
  51. class UnsupportedException(dbus.DBusException):
  52.     '''This exception is raised when some operation is not supported.'''
  53.  
  54.     _dbus_error_name = 'com.ubuntu.screenresolution.Mechanism.UnsupportedException'
  55.  
  56. class UsageError(dbus.DBusException):
  57.     '''This exception is raised when some operation was not used properly.'''
  58.  
  59.     _dbus_error_name = 'com.ubuntu.screenresolution.Mechanism.UsageError'
  60.  
  61. class PolicyKitService(dbus.service.Object):
  62.     '''A D-BUS service that uses PolicyKit for authorization.'''
  63.  
  64.     def _check_permission(self, sender, conn, action, reconnect=True):
  65.         '''
  66.         Verifies if the specified action is permitted, and raises
  67.         an AccessDeniedException if not.
  68.         '''
  69.         if sender is None and conn is None:
  70.             # called locally, not through D-BUS
  71.             return
  72.  
  73.         # get peer PID
  74.         dbus_info = dbus.Interface(conn.get_object('org.freedesktop.DBus',
  75.               '/org/freedesktop/DBus/Bus', False), 'org.freedesktop.DBus')
  76.         pid = dbus_info.GetConnectionUnixProcessID(sender)
  77.  
  78.         # query PolicyKit
  79.         polkit = dbus.Interface(get_service_bus().get_object(
  80.                 'org.freedesktop.PolicyKit1',
  81.                 '/org/freedesktop/PolicyKit1/Authority', False),
  82.                 'org.freedesktop.PolicyKit1.Authority')
  83.         try:
  84.             # we don't need is_challenge return here, since we call with AllowUserInteraction
  85.             (is_auth, _, details) = polkit.CheckAuthorization(
  86.                     ('unix-process', {'pid': dbus.UInt32(pid, variant_level=1)}),
  87.                     action, {'': ''}, dbus.UInt32(1), '', timeout=600)
  88.         except dbus.DBusException, e:
  89.             if reconnect and e._dbus_error_name == 'org.freedesktop.DBus.Error.ServiceUnknown':
  90.                 # polkitd timed out, connect again
  91.                 return self._check_polkit_privilege(sender, conn, action, reconnect=False)
  92.             else:
  93.                 raise
  94.  
  95.         if not is_auth:
  96.             logging.debug('_check_permission: sender %s on connection %s pid %i is not authorized for %s: %s' %
  97.                     (sender, conn, pid, action, str(details)))
  98.             raise AccessDeniedException(action)
  99.  
  100.  
  101. class BackendService(PolicyKitService):
  102.     '''A D-Bus service that PolicyKit controls access to.'''
  103.  
  104.     # pylint: disable-msg=C0103,E0602
  105.  
  106.     INTERFACE_NAME = 'com.ubuntu.ScreenResolution.Mechanism'
  107.     SERVICE_NAME   = 'com.ubuntu.ScreenResolution.Mechanism'
  108.     IDLE_TIMEOUT   =  30
  109.  
  110.     def __init__(self, connection=None, path='/'):        
  111.         if connection is None:
  112.             connection = get_service_bus()
  113.  
  114.         super(BackendService, self).__init__(connection, path)
  115.  
  116.         self.__name = dbus.service.BusName(self.SERVICE_NAME, connection)
  117.         self.__loop = gobject.MainLoop()
  118.         self.__timeout = 0
  119.         connection.add_message_filter(self.__message_filter)
  120.  
  121.     def __message_filter(self, connection, message):
  122.         '''
  123.         D-BUS message filter that keeps the service alive,
  124.         as long as it receives message.
  125.         '''
  126.  
  127.         if self.__timeout:
  128.             self.__start_idle_timeout()
  129.  
  130.         return HANDLER_RESULT_NOT_YET_HANDLED
  131.  
  132.     def __start_idle_timeout(self):
  133.         '''Restarts the timeout for terminating the service when idle.'''
  134.  
  135.         if self.__timeout:
  136.             gobject.source_remove(self.__timeout)
  137.  
  138.         self.__timeout = gobject.timeout_add(self.IDLE_TIMEOUT * 1000,
  139.                                              self.__timeout_cb)
  140.  
  141.     def __timeout_cb(self):
  142.         '''Timeout callback that terminates the service when idle.'''
  143.  
  144.         # Keep service alive, as long as additional objects are exported:
  145.         if self.connection.list_exported_child_objects('/'):
  146.             return True
  147.  
  148.         print 'Terminating %s due to inactivity.' % self.SERVICE_NAME
  149.         self.__loop.quit()
  150.  
  151.         return False
  152.  
  153.     def run(self):
  154.         '''Creates a GLib main loop for keeping the service alive.'''
  155.  
  156.         print 'Running %s.' % self.SERVICE_NAME
  157.         print ('Terminating it after %d seconds of inactivity.' 
  158.                % self.IDLE_TIMEOUT)
  159.  
  160.         self.__start_idle_timeout()
  161.         self.__loop.run()
  162.  
  163.  
  164.     # pylint: disable-msg=R0913
  165.     @dbus.service.method(dbus_interface=INTERFACE_NAME,
  166.                          in_signature='as', out_signature='b',
  167.                          sender_keyword='sender', connection_keyword='conn')   
  168.     def setVirtual(self, virtres, sender=None, conn=None):
  169.         '''
  170.         Replace the first line of this example with a source and a destination file
  171.         '''
  172.         self._check_permission(sender, conn,
  173.             'com.ubuntu.screenresolution.mechanism.configure')
  174.  
  175.         virtual = ' '.join(virtres)
  176.         
  177.         source = '/etc/X11/xorg.conf'
  178.         destination = '/etc/X11/xorg.conf'
  179.         
  180.         if os.path.exists(source):
  181.             #make a backup of the xorg.conf
  182.             backup = source + "." + time.strftime("%Y%m%d%H%M%S")
  183.             shutil.copyfile(source, backup)
  184.         
  185.         try:
  186.             a = xutils.XUtils(source)
  187.         except(IOError, xorgparser.ParseException):#if xorg.conf is missing or broken
  188.             a = xutils.XUtils()#start from scratch
  189.         
  190.         empty = True
  191.         for section in a.globaldict:
  192.             if len(a.globaldict[section]) > 0:
  193.                 empty = False
  194.                 break
  195.  
  196.         if empty:
  197.             a.makeSection('Device', 'Configured Video Device')
  198.             a.makeSection('Screen', identifier='Configured Screen Device')
  199.             a.addReference('Screen', 'Device', 'Configured Video Device', position=0)
  200.             a.makeSubSection('Screen', 'Display', position=0)
  201.             a.addSubOption('Screen', 'Display', 'Virtual', value=virtual, position=0)
  202.         
  203.         else:#if xorg.conf exists and is not empty
  204.             devicelen = len(a.globaldict['Device'])
  205.             screenlen = len(a.globaldict['Screen'])
  206.             
  207.             if screenlen == 0:
  208.                 screen = a.makeSection('Screen', identifier='Configured Screen Device')
  209.                 if devicelen == 0:
  210.                     device = a.makeSection('Device', 'Configured Video Device')
  211.                 else:
  212.                     device = 0
  213.                 a.addReference('Screen', 'Device', 'Configured Video Device', position=device)
  214.                 
  215.                 a.makeSubSection('Screen', 'Display', position=0)
  216.                 a.addSubOption('Screen', 'Display', 'Virtual', value=virtual, position=0)
  217.                 
  218.             else:#if at least 1 Screen section exists
  219.                 '''
  220.                 Set the virtual section in all the Screen sections
  221.                 '''
  222.                 for screen in a.globaldict['Screen']:
  223.                     a.makeSubSection('Screen', 'Display', position=screen)
  224.                     a.addSubOption('Screen', 'Display', 'Virtual', value=virtual, position=screen)
  225.  
  226.         '''
  227.         Write the changes to the destination file
  228.         '''
  229.         a.writeFile(destination)
  230.         return True
  231.     
  232.     @dbus.service.method(dbus_interface=INTERFACE_NAME,
  233.                          in_signature='s', out_signature='i',
  234.                          sender_keyword='sender', connection_keyword='conn')
  235.     def setDontZap(self, enable, sender=None, conn=None):
  236.         '''Try to set the DontZap option in the xorg.conf
  237.            and return the exit code of dontzap'''
  238.  
  239.         self._check_permission(sender, conn,
  240.             'com.ubuntu.screenresolution.mechanism.dontzap')
  241.  
  242.         dontzap_file = '/usr/bin/dontzap'
  243.         if not os.path.isfile(dontzap_file):
  244.             logging.error('/usr/bin/dontzap does not exist')
  245.             return 1
  246.         
  247.         if enable in ['--enable', '--disable']:
  248.             logging.debug('calling dontzap with %s' % enable)
  249.             retcode = subprocess.call([dontzap_file, enable])
  250.             return retcode
  251.         else:
  252.             logging.error('called with wrong arguments = %s' % enable)
  253.             return 1
  254.     
  255.     
  256. def get_service_bus():
  257.     '''Retrieves a reference to the D-BUS system bus.'''
  258.  
  259.     return dbus.SystemBus()
  260.  
  261. def get_service(bus=None):
  262.     '''Retrieves a reference to the D-BUS driven configuration service.'''
  263.  
  264.     if not bus:
  265.         bus = get_service_bus()
  266.  
  267.     service = bus.get_object(BackendService.SERVICE_NAME, '/')
  268.     service = dbus.Interface(service, BackendService.INTERFACE_NAME)
  269.  
  270.     return service
  271.  
  272. if __name__ == '__main__':
  273.     # Support full tracing when --debug switch is passed:
  274.     import sys
  275.     from sys import argv
  276.  
  277.     # Integrate DBus with GLib main loops.
  278.  
  279.     from dbus.mainloop.glib import DBusGMainLoop
  280.     DBusGMainLoop(set_as_default=True)
  281.  
  282.     # Run the service.
  283.  
  284.     if '--debug' in argv or '-d' in argv:
  285.         logging.basicConfig(stream=sys.stderr)
  286.         logging.getLogger().setLevel(logging.NOTSET)
  287.         
  288.     BackendService().run()
  289.  
  290.